//
// Created by Administrator on 2025/8/7.
//

#ifndef DOUBLECIRCLELIST_H
#define DOUBLECIRCLELIST_H

namespace doubleList {
struct node {
    explicit node(const int val = 0)
    : data_(val)
    , next_(nullptr)
    , prev_(nullptr)
    {}
    int data_;
    node *next_, *prev_;
};
    class iterator {
    public:
        explicit iterator(node* ptr = nullptr) : ptr_(ptr) {}
        ~iterator() {
            delete ptr_;
        }
        void operator++() {
            ptr_ = ptr_->next_;
        }
        void operator--() {
            ptr_ = ptr_->prev_;
        }
       bool operator!=(const iterator& it) const {
            return ptr_ != it.ptr_;
        }
        int operator*() const {
            return ptr_->data_;
        }
        private:
        node* ptr_;
    };
class doubleCircleList {
    public:
    // 构造函数，初始化一个双链表
    explicit doubleCircleList() {
        // 创建一个头结点
        head_ = new node();
        // 将头结点的next指针指向自身
        head_->next_ = head_;
        // 将头结点的pre指针指向自身
        head_->prev_ = head_;
    }
    ~doubleCircleList() {
        // 如果头节点为空，直接返回
        if (head_ == nullptr) {
            return;
        }
        // 定义一个指针p，指向头节点的下一个节点
        node* p = head_->next_;
        // 当p不等于头节点时，循环执行以下操作
        while (p!=head_) {
            // 将头节点指向p的下一个节点
            head_ = p->next_;
            // 删除p节点
            delete p;
            // 将p指向头节点
            p = head_;
        }
        // 删除头节点
        delete head_;
    }
    // 在链表末尾插入一个节点
    void insert_back(const int val) const {
        //创建一个新的节点
        node* p = new node(val);
        //找到尾节点
        node* tail = head_->prev_;
        //将尾节点的next指针指向新节点
        tail->next_ = p;
        //将新节点的prev指针指向尾节点
        p->prev_ = tail;
        //将新节点的next指针指向头节点
        p->next_ = head_;
        //将头节点的prev指针指向新节点
        head_->prev_ = p;

    }
    // 在链表开头插入一个节点
    void insert_front(const int val) const {
        //创建一个新的节点
        auto p = new node(val);
        //找到头节点的下一个节点
        node* first = head_->next_;
        //将头节点的next指针指向新节点
        head_->next_ = p;
        //将新节点的prev指针指向头节点
        p->prev_ = head_;
        //将新节点的next指针指向头节点的下一个节点
        p->next_ = first;
        //将头节点的下一个节点的prev指针指向新节点
        first->prev_ = p;
    }
    //判断链表是不是空
    bool empty() const {
        return head_==nullptr ||head_->next_ == head_;
    }
    //打印链表
    void showList() const {
        if (empty()) {
            std::cout<<"链表是空链表"<<std::endl;
            return;
        }
        //找到一个
        node* p = head_->next_;
        while (p!=head_) {
            std::cout<<p->data_<<" ";
            p = p->next_;
        }
        std::cout<<std::endl;
    }
    //删除链表中的节点
    void deleteNode(const int val) const {
        if (empty()) {
            return ;
        }
        const node* p = head_->next_;
        while (p!=head_) {
            if (p->data_==val) {
                //找到当前节点的前后节点
                node* prev = p->prev_;
                node* next = p->next_;
                //将前一个节点的next指针指向后一个节点
                prev->next_ = next;
                //将后一个节点的prev指针指向前一个节点
                next->prev_ = prev;
                //删除当前节点
                delete p;
                p = nullptr;
                break;
            }else {
                p = p->next_;
            }

        }
    }
    //删除值为val的所有节点
    void deleteAllNode(const int val) const {
        //如果链表为空，则直接返回
        if (empty()) {
            return ;
        }
        //定义一个指针p，指向头节点的下一个节点
        const node* p = head_->next_;
        //遍历链表
        while (p!=head_) {
            //如果当前节点的值为val
            if (p->data_==val) {
                //找到当前节点的前后节点
                node* prev = p->prev_;
                node* next = p->next_;
                //将前一个节点的next指针指向后一个节点
                prev->next_ = next;
                //将后一个节点的prev指针指向前一个节点
                next->prev_ = prev;
                //删除当前节点
                delete p;
                p = next;
            }else {
                //如果当前节点的值不为val，则继续遍历
                p = p->next_;
            }

        }
    }
    //查找指定的元素
    // 查找指定值是否存在
    bool find(const int val) const {
        // 如果链表为空，则返回false
        if (empty()) {
            return false;
        }
        // 定义一个指针p，指向链表的头节点的下一个节点
        const node* p = head_->next_;
        // 遍历链表，如果找到指定值，则返回true
        while (p!=head_) {
            if (p->data_ == val) {
                return true;
            }
            // 指针p指向下一个节点
            p = p->next_;
        }
        // 如果遍历完整个链表都没有找到指定值，则返回false
        return false;
    }
    //迭代器的起始部分
    iterator begin() const {
        return iterator(head_->next_);
    }
    //迭代器的结束部分
    iterator end() const {
        return iterator(head_);
    }


private:
    node *head_;

};

} // doubleList

#endif //DOUBLECIRCLELIST_H
